#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Django to Jinja
~~~~~~~~~~~~~~~

Helper module that can convert django templates into Jinja2 templates.

This file is not intended to be used as stand alone application but to
be used as library.  To convert templates you basically create your own
writer, add extra conversion logic for your custom template tags,
configure your django environment and run the `convert_templates`
function.

Here a simple example::

    # configure django (or use settings.configure)
    import os
    os.environ['DJANGO_SETTINGS_MODULE'] = 'yourapplication.settings'
    from yourapplication.foo.templatetags.bar import MyNode

    from django2jinja import Writer, convert_templates

    def write_my_node(writer, node):
        writer.start_variable()
        writer.write('myfunc(')
        for idx, arg in enumerate(node.args):
            if idx:
                writer.write(', ')
            writer.node(arg)
        writer.write(')')
        writer.end_variable()

    writer = Writer()
    writer.node_handlers[MyNode] = write_my_node
    convert_templates('/path/to/output/folder', writer=writer)

Here is an example hos to automatically translate your django
variables to ambari_jinja2::

    import re
    # List of tuple (Match pattern, Replace pattern, Exclusion pattern)

    var_re  = ((re.compile(r"(u|user)\.is_authenticated"), r"\1.is_authenticated()", None),
              (re.compile(r"\.non_field_errors"), r".non_field_errors()", None),
              (re.compile(r"\.label_tag"), r".label_tag()", None),
              (re.compile(r"\.as_dl"), r".as_dl()", None),
              (re.compile(r"\.as_table"), r".as_table()", None),
              (re.compile(r"\.as_widget"), r".as_widget()", None),
              (re.compile(r"\.as_hidden"), r".as_hidden()", None),

              (re.compile(r"\.get_([0-9_\w]+)_url"), r".get_\1_url()", None),
              (re.compile(r"\.url"), r".url()", re.compile(r"(form|calendar).url")),
              (re.compile(r"\.get_([0-9_\w]+)_display"), r".get_\1_display()", None),
              (re.compile(r"loop\.counter"), r"loop.index", None),
              (re.compile(r"loop\.revcounter"), r"loop.revindex", None),
              (re.compile(r"request\.GET\.([0-9_\w]+)"), r"request.GET.get('\1', '')", None),
              (re.compile(r"request\.get_host"), r"request.get_host()", None),

              (re.compile(r"\.all(?!_)"), r".all()", None),
              (re.compile(r"\.all\.0"), r".all()[0]", None),
              (re.compile(r"\.([0-9])($|\s+)"), r"[\1]\2", None),
              (re.compile(r"\.items"), r".items()", None),
    )
    writer = Writer(var_re=var_re)

For details about the writing process have a look at the module code.

:copyright: (c) 2009 by the Jinja Team.
:license: BSD.
"""

import re
import os
import sys
from ambari_jinja2.defaults import *
from django.conf import settings
from django.template import (
  defaulttags as core_tags,
  loader,
  TextNode,
  FilterExpression,
  libraries,
  Variable,
  loader_tags,
  TOKEN_TEXT,
  TOKEN_VAR,
)
from django.template.debug import DebugVariableNode as VariableNode
from django.templatetags import i18n as i18n_tags
from io import StringIO


_node_handlers = {}
_resolved_filters = {}
_newline_re = re.compile(r"(?:\r\n|\r|\n)")


# Django stores an itertools object on the cycle node.  Not only is this
# thread unsafe but also a problem for the converter which needs the raw
# string values passed to the constructor to create a jinja loop.cycle()
# call from it.
_old_cycle_init = core_tags.CycleNode.__init__


def _fixed_cycle_init(self, cyclevars, variable_name=None):
  self.raw_cycle_vars = map(Variable, cyclevars)
  _old_cycle_init(self, cyclevars, variable_name)


core_tags.CycleNode.__init__ = _fixed_cycle_init


def node(cls):
  def proxy(f):
    _node_handlers[cls] = f
    return f

  return proxy


def convert_templates(
  output_dir, extensions=(".html", ".txt"), writer=None, callback=None
):
  """Iterates over all templates in the template dirs configured and
  translates them and writes the new templates into the output directory.
  """
  if writer is None:
    writer = Writer()

  def filter_templates(files):
    for filename in files:
      ifilename = filename.lower()
      for extension in extensions:
        if ifilename.endswith(extension):
          yield filename

  def translate(f, loadname):
    template = loader.get_template(loadname)
    original = writer.stream
    writer.stream = f
    writer.body(template.nodelist)
    writer.stream = original

  if callback is None:

    def callback(template):
      print(template)

  for directory in settings.TEMPLATE_DIRS:
    for dirname, _, files in os.walk(directory):
      dirname = dirname[len(directory) + 1 :]
      for filename in filter_templates(files):
        source = os.path.normpath(os.path.join(dirname, filename))
        target = os.path.join(output_dir, dirname, filename)
        basetarget = os.path.dirname(target)
        if not os.path.exists(basetarget):
          os.makedirs(basetarget)
        callback(source)
        f = file(target, "w")
        try:
          translate(f, source)
        finally:
          f.close()


class Writer(object):
  """The core writer class."""

  def __init__(
    self,
    stream=None,
    error_stream=None,
    block_start_string=BLOCK_START_STRING,
    block_end_string=BLOCK_END_STRING,
    variable_start_string=VARIABLE_START_STRING,
    variable_end_string=VARIABLE_END_STRING,
    comment_start_string=COMMENT_START_STRING,
    comment_end_string=COMMENT_END_STRING,
    initial_autoescape=True,
    use_jinja_autoescape=False,
    custom_node_handlers=None,
    var_re=[],
    env=None,
  ):
    if stream is None:
      stream = sys.stdout
    if error_stream is None:
      error_stream = sys.stderr
    self.stream = stream
    self.error_stream = error_stream
    self.block_start_string = block_start_string
    self.block_end_string = block_end_string
    self.variable_start_string = variable_start_string
    self.variable_end_string = variable_end_string
    self.comment_start_string = comment_start_string
    self.comment_end_string = comment_end_string
    self.autoescape = initial_autoescape
    self.spaceless = False
    self.use_jinja_autoescape = use_jinja_autoescape
    self.node_handlers = dict(_node_handlers, **(custom_node_handlers or {}))
    self._loop_depth = 0
    self._filters_warned = set()
    self.var_re = var_re
    self.env = env

  def enter_loop(self):
    """Increments the loop depth so that write functions know if they
    are in a loop.
    """
    self._loop_depth += 1

  def leave_loop(self):
    """Reverse of enter_loop."""
    self._loop_depth -= 1

  @property
  def in_loop(self):
    """True if we are in a loop."""
    return self._loop_depth > 0

  def write(self, s):
    """Writes stuff to the stream."""
    self.stream.write(s.encode(settings.FILE_CHARSET))

  def print_expr(self, expr):
    """Open a variable tag, write to the string to the stream and close."""
    self.start_variable()
    self.write(expr)
    self.end_variable()

  def _post_open(self):
    if self.spaceless:
      self.write("- ")
    else:
      self.write(" ")

  def _pre_close(self):
    if self.spaceless:
      self.write(" -")
    else:
      self.write(" ")

  def start_variable(self):
    """Start a variable."""
    self.write(self.variable_start_string)
    self._post_open()

  def end_variable(self, always_safe=False):
    """End a variable."""
    if not always_safe and self.autoescape and not self.use_jinja_autoescape:
      self.write("|e")
    self._pre_close()
    self.write(self.variable_end_string)

  def start_block(self):
    """Starts a block."""
    self.write(self.block_start_string)
    self._post_open()

  def end_block(self):
    """Ends a block."""
    self._pre_close()
    self.write(self.block_end_string)

  def tag(self, name):
    """Like `print_expr` just for blocks."""
    self.start_block()
    self.write(name)
    self.end_block()

  def variable(self, name):
    """Prints a variable.  This performs variable name transformation."""
    self.write(self.translate_variable_name(name))

  def literal(self, value):
    """Writes a value as literal."""
    value = repr(value)
    if value[:2] in ('u"', "u'"):
      value = value[1:]
    self.write(value)

  def filters(self, filters, is_block=False):
    """Dumps a list of filters."""
    want_pipe = not is_block
    for filter, args in filters:
      name = self.get_filter_name(filter)
      if name is None:
        self.warn(f"Could not find filter {name}")
        continue
      if name not in DEFAULT_FILTERS and name not in self._filters_warned:
        self._filters_warned.add(name)
        self.warn(f"Filter {name} probably doesn't exist in Jinja")
      if not want_pipe:
        want_pipe = True
      else:
        self.write("|")
      self.write(name)
      if args:
        self.write("(")
        for idx, (is_var, value) in enumerate(args):
          if idx:
            self.write(", ")
          if is_var:
            self.node(value)
          else:
            self.literal(value)
        self.write(")")

  def get_location(self, origin, position):
    """Returns the location for an origin and position tuple as name
    and lineno.
    """
    if hasattr(origin, "source"):
      source = origin.source
      name = "<unknown source>"
    else:
      source = origin.loader(origin.loadname, origin.dirs)[0]
      name = origin.loadname
    lineno = len(_newline_re.findall(source[: position[0]])) + 1
    return name, lineno

  def warn(self, message, node=None):
    """Prints a warning to the error stream."""
    if node is not None and hasattr(node, "source"):
      filename, lineno = self.get_location(*node.source)
      message = "[%s:%d] %s" % (filename, lineno, message)
    print(message, file=self.error_stream)

  def translate_variable_name(self, var):
    """Performs variable name translation."""
    if self.in_loop and var == "forloop" or var.startswith("forloop."):
      var = var[3:]

    for reg, rep, unless in self.var_re:
      no_unless = unless and unless.search(var) or True
      if reg.search(var) and no_unless:
        var = reg.sub(rep, var)
        break
    return var

  def get_filter_name(self, filter):
    """Returns the filter name for a filter function or `None` if there
    is no such filter.
    """
    if filter not in _resolved_filters:
      for library in libraries.values():
        for key, value in library.filters.items():
          _resolved_filters[value] = key
    return _resolved_filters.get(filter, None)

  def node(self, node):
    """Invokes the node handler for a node."""
    for cls, handler in self.node_handlers.items():
      if type(node) is cls or type(node).__name__ == cls:
        handler(self, node)
        break
    else:
      self.warn(
        f"Untranslatable node {node.__module__}.{node.__class__.__name__} found",
        node,
      )

  def body(self, nodes):
    """Calls node() for every node in the iterable passed."""
    for node in nodes:
      self.node(node)


@node(TextNode)
def text_node(writer, node):
  writer.write(node.s)


@node(Variable)
def variable(writer, node):
  if node.translate:
    writer.warn("i18n system used, make sure to install translations", node)
    writer.write("_(")
  if node.literal is not None:
    writer.literal(node.literal)
  else:
    writer.variable(node.var)
  if node.translate:
    writer.write(")")


@node(VariableNode)
def variable_node(writer, node):
  writer.start_variable()
  if (
    node.filter_expression.var.var == "block.super"
    and not node.filter_expression.filters
  ):
    writer.write("super()")
  else:
    writer.node(node.filter_expression)
  writer.end_variable()


@node(FilterExpression)
def filter_expression(writer, node):
  writer.node(node.var)
  writer.filters(node.filters)


@node(core_tags.CommentNode)
def comment_tag(writer, node):
  pass


@node(core_tags.DebugNode)
def comment_tag(writer, node):
  writer.warn(
    "Debug tag detected.  Make sure to add a global function "
    "called debug to the namespace.",
    node=node,
  )
  writer.print_expr("debug()")


@node(core_tags.ForNode)
def for_loop(writer, node):
  writer.start_block()
  writer.write("for ")
  for idx, var in enumerate(node.loopvars):
    if idx:
      writer.write(", ")
    writer.variable(var)
  writer.write(" in ")
  if node.is_reversed:
    writer.write("(")
  writer.node(node.sequence)
  if node.is_reversed:
    writer.write(")|reverse")
  writer.end_block()
  writer.enter_loop()
  writer.body(node.nodelist_loop)
  writer.leave_loop()
  writer.tag("endfor")


@node(core_tags.IfNode)
def if_condition(writer, node):
  writer.start_block()
  writer.write("if ")
  join_with = "and"
  if node.link_type == core_tags.IfNode.LinkTypes.or_:
    join_with = "or"

  for idx, (ifnot, expr) in enumerate(node.bool_exprs):
    if idx:
      writer.write(f" {join_with} ")
    if ifnot:
      writer.write("not ")
    writer.node(expr)
  writer.end_block()
  writer.body(node.nodelist_true)
  if node.nodelist_false:
    writer.tag("else")
    writer.body(node.nodelist_false)
  writer.tag("endif")


@node(core_tags.IfEqualNode)
def if_equal(writer, node):
  writer.start_block()
  writer.write("if ")
  writer.node(node.var1)
  if node.negate:
    writer.write(" != ")
  else:
    writer.write(" == ")
  writer.node(node.var2)
  writer.end_block()
  writer.body(node.nodelist_true)
  if node.nodelist_false:
    writer.tag("else")
    writer.body(node.nodelist_false)
  writer.tag("endif")


@node(loader_tags.BlockNode)
def block(writer, node):
  writer.tag("block " + node.name.replace("-", "_").rstrip("_"))
  node = node
  while node.parent is not None:
    node = node.parent
  writer.body(node.nodelist)
  writer.tag("endblock")


@node(loader_tags.ExtendsNode)
def extends(writer, node):
  writer.start_block()
  writer.write("extends ")
  if node.parent_name_expr:
    writer.node(node.parent_name_expr)
  else:
    writer.literal(node.parent_name)
  writer.end_block()
  writer.body(node.nodelist)


@node(loader_tags.ConstantIncludeNode)
@node(loader_tags.IncludeNode)
def include(writer, node):
  writer.start_block()
  writer.write("include ")
  if hasattr(node, "template"):
    writer.literal(node.template.name)
  else:
    writer.node(node.template_name)
  writer.end_block()


@node(core_tags.CycleNode)
def cycle(writer, node):
  if not writer.in_loop:
    writer.warn("Untranslatable free cycle (cycle outside loop)", node=node)
    return
  if node.variable_name is not None:
    writer.start_block()
    writer.write(f"set {node.variable_name} = ")
  else:
    writer.start_variable()
  writer.write("loop.cycle(")
  for idx, var in enumerate(node.raw_cycle_vars):
    if idx:
      writer.write(", ")
    writer.node(var)
  writer.write(")")
  if node.variable_name is not None:
    writer.end_block()
  else:
    writer.end_variable()


@node(core_tags.FilterNode)
def filter(writer, node):
  writer.start_block()
  writer.write("filter ")
  writer.filters(node.filter_expr.filters, True)
  writer.end_block()
  writer.body(node.nodelist)
  writer.tag("endfilter")


@node(core_tags.AutoEscapeControlNode)
def autoescape_control(writer, node):
  original = writer.autoescape
  writer.autoescape = node.setting
  writer.body(node.nodelist)
  writer.autoescape = original


@node(core_tags.SpacelessNode)
def spaceless(writer, node):
  original = writer.spaceless
  writer.spaceless = True
  writer.warn("entering spaceless mode with different semantics", node)
  # do the initial stripping
  nodelist = list(node.nodelist)
  if nodelist:
    if isinstance(nodelist[0], TextNode):
      nodelist[0] = TextNode(nodelist[0].s.lstrip())
    if isinstance(nodelist[-1], TextNode):
      nodelist[-1] = TextNode(nodelist[-1].s.rstrip())
  writer.body(nodelist)
  writer.spaceless = original


@node(core_tags.TemplateTagNode)
def template_tag(writer, node):
  tag = {
    "openblock": writer.block_start_string,
    "closeblock": writer.block_end_string,
    "openvariable": writer.variable_start_string,
    "closevariable": writer.variable_end_string,
    "opencomment": writer.comment_start_string,
    "closecomment": writer.comment_end_string,
    "openbrace": "{",
    "closebrace": "}",
  }.get(node.tagtype)
  if tag:
    writer.start_variable()
    writer.literal(tag)
    writer.end_variable()


@node(core_tags.URLNode)
def url_tag(writer, node):
  writer.warn("url node used.  make sure to provide a proper url() " "function", node)
  if node.asvar:
    writer.start_block()
    writer.write(f"set {node.asvar} = ")
  else:
    writer.start_variable()
  autoescape = writer.autoescape
  writer.write("url(")
  writer.literal(node.view_name)
  for arg in node.args:
    writer.write(", ")
    writer.node(arg)
  for key, arg in node.kwargs.items():
    writer.write(f", {key}=")
    writer.node(arg)
  writer.write(")")
  if node.asvar:
    writer.end_block()
  else:
    writer.end_variable()


@node(core_tags.WidthRatioNode)
def width_ratio(writer, node):
  writer.warn(
    "widthratio expanded into formula.  You may want to provide "
    "a helper function for this calculation",
    node,
  )
  writer.start_variable()
  writer.write("(")
  writer.node(node.val_expr)
  writer.write(" / ")
  writer.node(node.max_expr)
  writer.write(" * ")
  writer.write(str(int(node.max_width)))
  writer.write(")|round|int")
  writer.end_variable(always_safe=True)


@node(core_tags.WithNode)
def with_block(writer, node):
  writer.warn(
    "with block expanded into set statement.  This could cause "
    "variables following that block to be overriden.",
    node,
  )
  writer.start_block()
  writer.write(f"set {node.name} = ")
  writer.node(node.var)
  writer.end_block()
  writer.body(node.nodelist)


@node(core_tags.RegroupNode)
def regroup(writer, node):
  if node.expression.var.literal:
    writer.warn(
      "literal in groupby filter used.   Behavior in that "
      "situation is undefined and translation is skipped.",
      node,
    )
    return
  elif node.expression.filters:
    writer.warn(
      "filters in groupby filter used.   Behavior in that "
      "situation is undefined which is most likely a bug "
      "in your code.  Filters were ignored.",
      node,
    )
  writer.start_block()
  writer.write(f"set {node.var_name} = ")
  writer.node(node.target)
  writer.write("|groupby(")
  writer.literal(node.expression.var.var)
  writer.write(")")
  writer.end_block()


@node(core_tags.LoadNode)
def warn_load(writer, node):
  writer.warn("load statement used which was ignored on conversion", node)


@node(i18n_tags.GetAvailableLanguagesNode)
def get_available_languages(writer, node):
  writer.warn("make sure to provide a get_available_languages function", node)
  writer.tag(
    f"set {writer.translate_variable_name(node.variable)} = get_available_languages()"
  )


@node(i18n_tags.GetCurrentLanguageNode)
def get_current_language(writer, node):
  writer.warn("make sure to provide a get_current_language function", node)
  writer.tag(
    f"set {writer.translate_variable_name(node.variable)} = get_current_language()"
  )


@node(i18n_tags.GetCurrentLanguageBidiNode)
def get_current_language_bidi(writer, node):
  writer.warn("make sure to provide a get_current_language_bidi function", node)
  writer.tag(
    "set %s = get_current_language_bidi()"
    % writer.translate_variable_name(node.variable)
  )


@node(i18n_tags.TranslateNode)
def simple_gettext(writer, node):
  writer.warn("i18n system used, make sure to install translations", node)
  writer.start_variable()
  writer.write("_(")
  writer.node(node.value)
  writer.write(")")
  writer.end_variable()


@node(i18n_tags.BlockTranslateNode)
def translate_block(writer, node):
  first_var = []
  variables = set()

  def touch_var(name):
    variables.add(name)
    if not first_var:
      first_var.append(name)

  def dump_token_list(tokens):
    for token in tokens:
      if token.token_type == TOKEN_TEXT:
        writer.write(token.contents)
      elif token.token_type == TOKEN_VAR:
        writer.print_expr(token.contents)
        touch_var(token.contents)

  writer.warn("i18n system used, make sure to install translations", node)
  writer.start_block()
  writer.write("trans")
  idx = -1
  for idx, (key, var) in enumerate(node.extra_context.items()):
    if idx:
      writer.write(",")
    writer.write(f" {key}=")
    touch_var(key)
    writer.node(var.filter_expression)

  have_plural = False
  plural_var = None
  if node.plural and node.countervar and node.counter:
    have_plural = True
    plural_var = node.countervar
    if plural_var not in variables:
      if idx > -1:
        writer.write(",")
      touch_var(plural_var)
      writer.write(f" {plural_var}=")
      writer.node(node.counter)

  writer.end_block()
  dump_token_list(node.singular)
  if node.plural and node.countervar and node.counter:
    writer.start_block()
    writer.write("pluralize")
    if node.countervar != first_var[0]:
      writer.write(" " + node.countervar)
    writer.end_block()
    dump_token_list(node.plural)
  writer.tag("endtrans")


@node("SimpleNode")
def simple_tag(writer, node):
  """Check if the simple tag exist as a filter in"""
  name = node.tag_name
  if (
    writer.env and name not in writer.env.filters and name not in writer._filters_warned
  ):
    writer._filters_warned.add(name)
    writer.warn(f"Filter {name} probably doesn't exist in Jinja")

  if not node.vars_to_resolve:
    # No argument, pass the request
    writer.start_variable()
    writer.write("request|")
    writer.write(name)
    writer.end_variable()
    return

  first_var = node.vars_to_resolve[0]
  args = node.vars_to_resolve[1:]
  writer.start_variable()

  # Copied from Writer.filters()
  writer.node(first_var)

  writer.write("|")
  writer.write(name)
  if args:
    writer.write("(")
    for idx, var in enumerate(args):
      if idx:
        writer.write(", ")
      if var.var:
        writer.node(var)
      else:
        writer.literal(var.literal)
    writer.write(")")
  writer.end_variable()


# get rid of node now, it shouldn't be used normally
del node
